package main

import (
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"os"
	"time"

	"github.com/gin-contrib/cors"
	"github.com/gin-gonic/gin"
)

var configManager *ConfigManager

// IPInfo 存储 IP 地址及其来源信息
type IPInfo struct {
	Address string
	Source  string
}

// getLocalIPs 获取本机所有 IP 地址，仅用于调试信息
func getLocalIPs() []IPInfo {
	var ips []IPInfo

	// 添加 localhost
	ips = append(ips, IPInfo{Address: "127.0.0.1", Source: "localhost"})

	// 获取所有网络接口
	interfaces, err := net.Interfaces()
	if err != nil {
		return ips
	}

	// 遍历所有网络接口
	for _, iface := range interfaces {
		// 跳过 down 状态的接口
		if iface.Flags&net.FlagUp == 0 {
			continue
		}

		// 获取接口的地址
		addrs, err := iface.Addrs()
		if err != nil {
			continue
		}

		// 遍历所有地址
		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}

			// 跳过 IPv6 地址
			if ip == nil || ip.IsLoopback() || ip.To4() == nil {
				continue
			}

			ips = append(ips, IPInfo{
				Address: ip.String(),
				Source:  iface.Name,
			})
		}
	}

	return ips
}

func main() {
	// 加载配置
	config, err := LoadConfig()
	if err != nil {
		fmt.Printf("Error loading config: %v\n", err)
		os.Exit(1)
	}

	// 初始化配置管理器
	var initErr error
	configManager, initErr = NewConfigManager()
	if initErr != nil {
		fmt.Printf("Failed to initialize config manager: %v\n", initErr)
	}

	// 获取本机 IP 地址
	ips := getLocalIPs()
	fmt.Println("Server IP addresses:")
	for _, ip := range ips {
		fmt.Printf("  %s (%s)\n", ip.Address, ip.Source)
	}

	// 设置 Gin 模式
	gin.SetMode(gin.ReleaseMode)
	if os.Getenv("GIN_MODE") != "" {
		gin.SetMode(os.Getenv("GIN_MODE"))
	}

	// 创建 Gin 引擎
	r := gin.Default()

	// 配置 CORS
	r.Use(cors.New(cors.Config{
		AllowOrigins:     []string{"*"},
		AllowMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
		AllowHeaders:     []string{"Origin", "Content-Type", "Accept", "Authorization"},
		ExposeHeaders:    []string{"Content-Length"},
		AllowCredentials: true,
		MaxAge:           12 * time.Hour,
	}))

	// 添加健康检查端点
	r.GET("/health", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"status": "ok",
			"time":   time.Now().Format(time.RFC3339),
		})
	})

	// API 路由组
	api := r.Group(config.App.ApiPrefix)
	{
		api.POST("/chat/completions", handleChatCompletions)
		api.GET("/apps", handleListModels)
		api.GET("/apps/:namespace/:name", handleGetModelConfig)
		api.GET("/datasets", handleListDatasets)
		api.GET("/datasets/:namespace/:name", handleGetDatasetConfig)
	}

	// 获取端口
	port := config.App.Port
	if envPort := os.Getenv("PORT"); envPort != "" {
		port = envPort
	}

	// 启动服务器
	serverAddr := fmt.Sprintf(":%s", port)
	fmt.Printf("Starting server on %s (API prefix: %s)\n", serverAddr, config.App.ApiPrefix)
	fmt.Printf("External port: %s\n", config.App.ExternalPort)
	fmt.Printf("Access the API at: http://localhost:%s%s/apps\n", config.App.ExternalPort, config.App.ApiPrefix)

	if err := r.Run(serverAddr); err != nil {
		fmt.Printf("Failed to start server: %v\n", err)
		os.Exit(1)
	}
}

// 处理聊天完成请求
func handleChatCompletions(c *gin.Context) {
	// 简单的响应，实际应用中可能需要调用模型服务
	c.JSON(200, gin.H{
		"id":      "chatcmpl-123",
		"object":  "chat.completion",
		"created": time.Now().Unix(),
		"model":   "gpt-3.5-turbo",
		"choices": []gin.H{
			{
				"index": 0,
				"message": gin.H{
					"role":    "assistant",
					"content": "Hello! How can I help you today?",
				},
				"finish_reason": "stop",
			},
		},
	})
}

// 处理获取模型列表请求
func handleListModels(c *gin.Context) {
	// 使用 configManager 获取应用列表
	if configManager == nil {
		c.JSON(500, gin.H{"error": "Config manager not initialized"})
		return
	}

	// 直接返回 configManager 中的应用列表
	c.JSON(200, configManager.appList)
}

func handleGetModelConfig(c *gin.Context) {
	namespace := c.Param("namespace")
	name := c.Param("name")
	configType := c.Query("type") // 获取查询参数 type

	// 添加日志以便调试
	fmt.Printf("Requesting config: namespace=%s, name=%s, type=%s\n", namespace, name, configType)

	config, exists := configManager.GetAppConfig(namespace, name, configType)
	if !exists {
		c.JSON(404, gin.H{"error": "Model not found"})
		return
	}

	c.JSON(200, config)
}

// 处理获取数据集列表请求
func handleListDatasets(c *gin.Context) {
	// 读取 datasets.json 文件
	datasetsData, err := os.ReadFile("static/datasets.json")
	if err != nil {
		c.JSON(500, gin.H{"error": fmt.Sprintf("Error reading datasets.json: %v", err)})
		return
	}

	// 解析 JSON 数据
	var datasets []map[string]interface{}
	if err := json.Unmarshal(datasetsData, &datasets); err != nil {
		c.JSON(500, gin.H{"error": fmt.Sprintf("Error parsing datasets.json: %v", err)})
		return
	}

	// 返回数据集列表
	c.JSON(200, datasets)
}

// 处理获取数据集配置请求
func handleGetDatasetConfig(c *gin.Context) {
	namespace := c.Param("namespace")
	name := c.Param("name")

	// 添加日志以便调试
	fmt.Printf("Requesting dataset config: namespace=%s, name=%s\n", namespace, name)

	// 读取 datasets.json 文件
	datasetsData, err := os.ReadFile("static/datasets.json")
	if err != nil {
		c.JSON(500, gin.H{"error": fmt.Sprintf("Error reading datasets.json: %v", err)})
		return
	}

	// 解析 JSON 数据
	var datasets []map[string]interface{}
	if err := json.Unmarshal(datasetsData, &datasets); err != nil {
		c.JSON(500, gin.H{"error": fmt.Sprintf("Error parsing datasets.json: %v", err)})
		return
	}

	// 查找匹配的数据集
	for _, dataset := range datasets {
		if dataset["namespace"] == namespace && dataset["name"] == name {
			c.JSON(200, dataset)
			return
		}
	}

	// 如果没有找到匹配的数据集，返回 404
	c.JSON(404, gin.H{"error": "Dataset not found"})
}
